package com.bjsxt;

import java.util.ArrayList;
import java.util.List;


/**ArrayList 容器类*/
//ArrayList 是List接口的实现类（接口是用来实现的），是List存储特征的具体实现
//  ArrayList 底层是用数组实现存储。特点：查询效率高，增删效率低，线程不安全
public class TestArrayList {
    public static void main(String[] args) {
        /*使用ArrayList容器来完成元素的存储*/
        //先去实例化ArrayList类  因为类是创建对象的模板，创建了才可以使用这个容器
        //对象的引用 ，用接口来定义，面向对象的过程就是面向接口的过程
        //list接口继承了Collection 所以用list
        List<String> list = new ArrayList<>();//实例化ArrayList容器
       // list.add("bjsxt"); 有返回值 ，以下写法
       boolean flag = list.add("bjsxt");
       boolean flag2 = list.add("itbz");
        System.out.println(flag);//如果元素添加成功 true
        //(index)索引的数值不能大于元素个数  这里不能是3
        list.add(1,"old");

        System.out.println("------获取元素------");
        /*E get（int index）  返回此列表中指定位置的元素*/
        /*E 是返回值  index 要返回元素的索引  异常：index<0||index>=size()*/
        //指定索引位置获取元素
        System.out.println(list.get(1));
        System.out.println(list.get(0));
        //通过循环获取集合中的元素
        //size();方法  集合中的个数
        for(int i =0;i<list.size();i++){
            System.out.println(list.get(i));
        }

        System.out.println("------替换元素-------");
        /*E set（int index,E element）取代指定位置上的元素 */
        //element 元素存储在指定位置  异常：index<0||index>=size()
        String val = list.set(0,"abc");
        System.out.println(val);  //返回被替换的元素
        for(int i =0;i<list.size();i++){
            System.out.println(list.get(i));
        }

        /*E remove(int index) 有返回值 删除指定位置的元素，后面的元素前移一位*/
        //返回的是删除的元素
        //根据位置删除
        System.out.println("-----根据位置删除元素-----");
        String value = list.remove(1);//删除old
        System.out.println(value);
        for (int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //根据指定元素删除
        System.out.println("-----根据指定元素删除-----");
        boolean flag3 = list.remove("itbz");
        System.out.println(flag3);
        for(int i=0;i< list.size();i++){
            System.out.println(list.get(i));
        }
        System.out.println("-----清空元素-----");
        /*void clear() 从这个列表删除的所有元素（可选操作）这个调用返回的列表是空的*/
        list.clear();
        System.out.println();

        System.out.println("----判断容器是否为空----");
        /*boolean isEmpty() 返回true表示列表不包含任何元素  false则表示有元素*/
        boolean flag4 = list.isEmpty();
        System.out.println(flag4);

        System.out.println("--------");
        list.add("itbz");
        list.add("bjsxt");
        list.add("good");
        list.add("itbz");
        list.add("itbz");

        boolean flag5 = list.isEmpty();
        System.out.println(flag5);

        System.out.println("-----判断容器中是否包含指定元素-----");
        /*boolean contains()  返回true表示列表包含指定元素  false则表示没有指定元素*/
        boolean flag6 = list.contains("itbz");
        System.out.println(flag6); //true
        System.out.println("------");
        boolean flag7 = list.contains("abc");
        System.out.println(flag7);//false

        System.out.println("------查找元素第一次出现的位置------");
        /*int indexOf()  int是返回值 返回第一次出现的位置*/
        //元素不存在返回-1
        int index = list.indexOf("itbz");
        System.out.println(index);// 0
        System.out.println("------查找元素最后一次出的位置-----");
        /*int lastIndexOf()*/
        int last = list.lastIndexOf("itbz");
        System.out.println(last);// 4
        System.out.println("---元素不存在返回-1---");
        int last1 = list.lastIndexOf("itbz22");
        System.out.println(last1); //-1

     //将单例集合转换成数组  不能在转化的方法调用时进行强制类型转换，可以逐个转换
     /*在Collection接口中，List继承了Collection接口，ArrayList类实现接口，*/
     System.out.println("------将ArrayList转换为Object数组------");
     //Object[] toArray[]   返回的是Object数组
     Object[] arr = list.toArray();
     //数组的转换
    /* for (int i=0;i<arr.length;i++){
      System.out.println(arr[i]);
     }*/
     //将数组里的元素强转为String类型
     for (int i=0;i<arr.length;i++){
      String str = (String)arr[i];//不能对整个数组强转，可以逐个转换为String
      System.out.println(str);
     }
    //不可以强制转换为String类型，虽然定义时是String
     //List<String> list = new ArrayList<>()，但是这是泛型的定义，泛型只是在
     //编译时起到校检作用，不是真正的把集合转换为String类型，运行以后仍然是存储Object类型
    // String[] str = (String[]) list.toArray(); 不可以强制转换
    /*java里的强转只能对某一个进行强转，不能对整个数组强转。
    * 如果本身是String类 返回的是Object类型 才可以整数组强转为String */
     System.out.println("-----转换为泛型类型数组----");
     /*<T>[] toArray[]      返回泛型数组
     * 可以将单例集合转换为指定类型数组，但是，类型需要参考泛型中的类型*/
     String[] str = list.toArray(new String[list.size()]);
     for(int i=0;i<str.length;i++){
      System.out.println(str[i]);
     }

     System.out.println("-----容器的并集操作-----");
     /*boolean addAll(Collection<?   String List>c )*/
     //注意集合不能为空，返回false
     List<String> a = new ArrayList<>();
     a.add("a");
     a.add("b");
     a.add("c");
     a.add("d");
     List<String> b = new ArrayList<>();
     b.add("f");
     b.add("b");
     b.add("c");
     b.add("g");

     boolean flag8 = a.addAll(b);
     System.out.println(flag8);
     for(String str1:a){   //将b集合并入a集合，这里是打印a集合
      System.out.println(str1);
     }

     System.out.println("-------容器的交集操作-----");
     /*boolean retainAll(collection<?>  c) */
     /**/
     List<String> a1 = new ArrayList<>();
     a1.add("a");
     a1.add("b");
     a1.add("c");
     a1.add("d");
     List<String> b2 = new ArrayList<>();
     b2.add("f");
     b2.add("b");
     b2.add("c");
     b2.add("g");

     boolean flag9 = a1.retainAll(b2);
     System.out.println(flag9);
     for(String str1:a1){
      System.out.println(str1);
     }

     System.out.println("------容器的差集操作-----");
     /*两个集合a与b，差集就是保留a集合有，而b集合没有的元素。如果b集合中有
      a集合的元素，就删除共有的元素*/
     //boolean removeAll(Collection<?> c)
     List<String> a2 = new ArrayList<>();
     a2.add("a");
     a2.add("b");
     a2.add("c");
     a2.add("d");
     List<String> b3 = new ArrayList<>();
     b3.add("f");
     b3.add("b");
     b3.add("c");
     b3.add("g");

     boolean flag00 = a2.removeAll(b3);
     System.out.println(flag00);
     for(String str3:a2){
      System.out.println(str3);
     }
    }

}
